package com.rw.tool.util.collection;

import java.util.*;

/**
 * 集合工具类
 */
public class CollectionUtil {
    /**
     * 判断集合是否为空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 随机列表，并且不改变原本的列表
     */
    public static <T> List<T> shuffle(List<T> list) {
        List<T> shuffleList = new ArrayList<>(list);
        Collections.shuffle(shuffleList);
        return shuffleList;
    }

    /**
     * 翻转列表，并且不改变原本的列表
     */
    public static <T> List<T> reverse(List<T> list) {
        List<T> reverseList = new ArrayList<>(list);
        Collections.reverse(reverseList);
        return reverseList;
    }

    /**
     * 排序列表，并且不改变原本的列表
     */
    public static <T extends Comparable<? super T>> List<T> sort(List<T> list) {
        List<T> sortList = new ArrayList<>(list);
        Collections.sort(sortList);
        return sortList;
    }

    /**
     * 排序列表，并且不改变原本的列表
     */
    public static <T> List<T> sort(List<T> list, Comparator<? super T> c) {
        List<T> sortList = new ArrayList<>(list);
        sortList.sort(c);
        return sortList;
    }

    /**
     * 两个集合的大小是否相等
     * 如果两集合其中有一个为null，则返回false
     * 如果两集合都为空，则返回true
     */
    public static boolean lengthEquals(Collection<?> left, Collection<?> right) {
        if (Objects.isNull(left) || Objects.isNull(right)) {
            return false;
        }
        return left.size() == right.size();
    }

    /**
     * 判断两个有序列表中的每一个元素是否相等
     */
    public static boolean equals(List<?> left, List<?> right) {
        if (!lengthEquals(left, right)) {
            return false;
        }

        // 使用迭代器遍历两集合，判断每一个是否相等
        Iterator<?> leftIterator = left.iterator();
        Iterator<?> rightIterator = right.iterator();
        while (leftIterator.hasNext() && rightIterator.hasNext()) {
            if (!Objects.equals(leftIterator.next(), rightIterator.next())) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断两个无序集合中的每一个元素是否一一对应
     */
    public static boolean equals(Set<?> left, Set<?> right) {
        if (!lengthEquals(left, right)) {
            return false;
        }

        // 使用迭代器遍历两集合，判断每一个是否相等
        for (Object data : left) {
            if (!right.contains(data)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 把数组变为List
     */
    @SafeVarargs
    public static <T> List<T> asList(T... t) {
        return Arrays.asList(t);
    }

    /**
     * 生成一个只有一个元素的列表
     */
    public static <T> List<T> single(T t) {
        return Collections.singletonList(t);
    }

    /**
     * 生成一个空的列表
     */
    public static <T> List<T> emptyList() {
        return Collections.emptyList();
    }
}
